//! 默克尔树模块 - 计算交易集合的根哈希值

use sha2::{Sha256, Digest};

/// 默克尔树结构（仅存储根哈希）
pub struct MerkleTree {
    pub root: String, // 根哈希的十六进制字符串
}

impl MerkleTree {
    /// 构建默克尔树（递归哈希计算）
    /// # 参数
    /// - transactions: 交易数据的二进制列表（已序列化）
    pub fn new(transactions: Vec<Vec<u8>>) -> Self {
        // 处理空交易的特殊情况
        if transactions.is_empty() {
            return MerkleTree { root: String::new() };
        }

        // 第一层：计算所有交易的叶子节点哈希
        let mut hashes: Vec<String> = transactions
            .into_iter()
            .map(|tx| Self::hash(tx))
            .collect();

        // 迭代计算直到得到根哈希
        while hashes.len() > 1 {
            let mut next_level = Vec::new();
            
            // 两两组合计算父节点哈希
            for i in (0..hashes.len()).step_by(2) {
                let left = &hashes[i];
                // 处理奇数节点情况（复制最后一个哈希）
                let right = if i + 1 < hashes.len() { 
                    &hashes[i + 1] 
                } else { 
                    left 
                };

                // 合并左右哈希并计算父哈希
                let combined = format!("{}{}", left, right);
                next_level.push(Self::hash(combined.into_bytes()));
            }
            hashes = next_level;
        }

        // 最终剩余的哈希即为根哈希
        MerkleTree { 
            root: hashes.pop().unwrap_or_default() 
        }
    }

    /// 计算单次SHA256哈希
    /// # 参数
    /// - data: 二进制数据输入
    fn hash(data: Vec<u8>) -> String {
        let mut hasher = Sha256::new();
        hasher.update(data);
        format!("{:x}", hasher.finalize()) // 转为十六进制小写
    }
}